diff --git a/system/libraries/Session.php b/system/libraries/Session.php
index afa4334..d4fdd3a 100644
--- a/system/libraries/Session.php
+++ b/system/libraries/Session.php
@@ -146,7 +146,7 @@
 		 * a new one.  If it does, we'll update it.
 		 *
 		 */
-		if ( ! $this->sess_read())
+		if (! $this->sess_read())
 		{
 			$this->sess_create();
 		}
@@ -214,7 +214,7 @@
 		
 		$session = @unserialize($this->strip_slashes($session));
 		
-		if ( ! is_array($session) OR ! isset($session['last_activity']))
+		if (! is_array($session) OR ! isset($session['last_activity']))
 		{
 			log_message('error', 'The session cookie data did not contain a valid array. This could be a possible hacking attempt.');
 			return FALSE;
@@ -439,7 +439,7 @@
 	 */		
 	function userdata($item)
 	{
-		return ( ! isset($this->userdata[$item])) ? FALSE : $this->userdata[$item];
+		return (! isset($this->userdata[$item])) ? FALSE : $this->userdata[$item];
 	}
 
 	// --------------------------------------------------------------------
@@ -452,7 +452,7 @@
 	 */	
 	function all_userdata()
 	{
-        return ( ! isset($this->userdata)) ? FALSE : $this->userdata;
+        return (! isset($this->userdata)) ? FALSE : $this->userdata;
 	}
 	
 	// --------------------------------------------------------------------
